{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# One Pixel Attack Tutorial\n",
    "## Part 1 - Cifar10\n",
    "\n",
    "### Dan Kondratyuk\n",
    "### September 15, 2019"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](images/pred2.png \"All it takes is one pixel\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook will demonstrate the one pixel attack with a few different convolutional neural network models. By using differential evolution, we find a special pixel that can modify a target image such that the network misclassifies the image (which it previously correctly classified).\n",
    "\n",
    "In theory, we want models that don't get fooled by such tiny changes. Especially in images, it is undesirable to have a small alteration in the input result in a drastic change in the output. However, even the most accurate neural networks are susceptible to this type of attack.\n",
    "\n",
    "To read more about it, see [the original paper](https://arxiv.org/abs/1710.08864), or the authors' [official repo](https://github.com/Carina02/One-Pixel-Attack).\n",
    "\n",
    "Let's get started."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ensure that you have `numpy`, `pandas`, `scipy`, `matplotlib`, `tensorflow-gpu`, and `keras` installed.\n",
    "\n",
    "Alternatively, you may [run this notebook in Google Colab](https://colab.research.google.com/drive/1Zq1kGP9C7i-70-SXyuEEaqYngtyQZMn7). Note: colab allows you to run this notebook on GPU, free of charge. Simply select \"GPU\" in the Accelerator drop-down in Notebook Settings (either through the Edit menu or the command palette at cmd/ctrl-shift-P)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/hyper/Documents/anaconda3/lib/python3.6/site-packages/h5py/__init__.py:34: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n",
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "# If running in Google Colab, import files\n",
    "try:\n",
    "    import google.colab\n",
    "    in_colab = True\n",
    "except:\n",
    "    in_colab = False\n",
    "\n",
    "if in_colab:\n",
    "    !git clone https://github.com/Hyperparticle/one-pixel-attack-keras.git\n",
    "    !mv -v one-pixel-attack-keras/* .\n",
    "    !rm -rf one-pixel-attack-keras\n",
    "\n",
    "# Python Libraries\n",
    "%matplotlib inline\n",
    "import pickle\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib\n",
    "from keras.datasets import cifar10\n",
    "from keras import backend as K\n",
    "\n",
    "# Custom Networks\n",
    "from networks.lenet import LeNet\n",
    "from networks.pure_cnn import PureCnn\n",
    "from networks.network_in_network import NetworkInNetwork\n",
    "from networks.resnet import ResNet\n",
    "from networks.densenet import DenseNet\n",
    "from networks.wide_resnet import WideResNet\n",
    "from networks.capsnet import CapsNet\n",
    "\n",
    "# Helper functions\n",
    "from differential_evolution import differential_evolution\n",
    "import helper\n",
    "\n",
    "matplotlib.style.use('ggplot')\n",
    "np.random.seed(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For this attack, we will use the [Cifar10 dataset](https://www.cs.toronto.edu/~kriz/cifar.html) packaged by Keras. The task of the dataset is to correctly classify a 32x32 pixel image in 1 of 10 categories (e.g., bird, deer, truck).\n",
    "\n",
    "The code below will load the Cifar10 dataset. Keras will need to download the dataset if it is not cached locally already."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "(x_train, y_train), (x_test, y_test) = cifar10.load_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access and display any image in the dataset by its index. For instance, here is a horse."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f94d3d830f0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "image_id = 99 # Image index in the test set\n",
    "helper.plot_image(x_test[image_id])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Image Perturbation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To begin, we need a function to modify one or more pixels in an image. \n",
    "\n",
    "We can define the perturbation of a pixel as a 5-tuple \n",
    "\n",
    "$$\\textbf{x} = (x, y, r, g, b)$$\n",
    "\n",
    "where $x, y$ are the coordinates of the pixel from 0 to 31, and $r,g,b$ are the red, green, and blue values from 0 to 255. Then multiple perturbations can simply be a concatenation of these tuples:\n",
    "\n",
    "$$X = (x_1, y_1, r_1, g_1, b_1, x_2, y_2, r_2, g_2, b_2, ...)$$\n",
    "\n",
    "We could instead use an array of tuples, but the optimization algorithm we will use requires it to be a flat 1-d vector.\n",
    "\n",
    "Then the function to perturb an image can take as an input the image and $X$, and output a copy of the image with each pixel at $x_i, y_i$ modified to have the color $r_i, g_i, b_i$. To speed up computation, we will batch together an array of $X$ perturbations, denoted $X_S$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def perturb_image(xs, img):\n",
    "    # If this function is passed just one perturbation vector,\n",
    "    # pack it in a list to keep the computation the same\n",
    "    if xs.ndim < 2:\n",
    "        xs = np.array([xs])\n",
    "    \n",
    "    # Copy the image n == len(xs) times so that we can \n",
    "    # create n new perturbed images\n",
    "    tile = [len(xs)] + [1]*(xs.ndim+1)\n",
    "    imgs = np.tile(img, tile)\n",
    "    \n",
    "    # Make sure to floor the members of xs as int types\n",
    "    xs = xs.astype(int)\n",
    "    \n",
    "    for x,img in zip(xs, imgs):\n",
    "        # Split x into an array of 5-tuples (perturbation pixels)\n",
    "        # i.e., [[x,y,r,g,b], ...]\n",
    "        pixels = np.split(x, len(x) // 5)\n",
    "        for pixel in pixels:\n",
    "            # At each pixel's x,y position, assign its rgb value\n",
    "            x_pos, y_pos, *rgb = pixel\n",
    "            img[x_pos, y_pos] = rgb\n",
    "    \n",
    "    return imgs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can modify the pixels of any image we want.\n",
    "\n",
    "Let's modify our horse image by making pixel (16,16) yellow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f94caaaa7b8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "image_id = 99 # Image index in the test set\n",
    "pixel = np.array([16, 16, 255, 255, 0]) # pixel = x,y,r,g,b\n",
    "image_perturbed = perturb_image(pixel, x_test[image_id])[0]\n",
    "\n",
    "helper.plot_image(image_perturbed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To demonstrate the attack, we need some neural network models trained on the Cifar10 dataset. We will now load some pretrained models, which can be found in the `networks/models` directory.\n",
    "\n",
    "It is recommended to use Keras with a GPU enabled. If you're [running in Google Colab](https://colab.research.google.com/drive/1Zq1kGP9C7i-70-SXyuEEaqYngtyQZMn7), you can enable a GPU instance by selecting `Runtime > Change runtime type > Hardware accelerator > GPU` (you will need to re-run all cells). The code below can be used to check (if using TensorFlow)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['/job:localhost/replica:0/task:0/device:GPU:0']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Should output /device:GPU:0\n",
    "K.tensorflow_backend._get_available_gpus()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are two models included in this repository, `lenet` and `resnet` which will be loaded from disk automatically.\n",
    "\n",
    "Optionally, you may [download the larger, more accurate models](https://www.dropbox.com/sh/dvatkpjl0sn79kn/AAC9L4puJ_sdFUkDZfr5SFkLa?dl=0) (e.g., Capsule Network, DenseNet, etc.). Make sure to copy the models into the `networks/models/` directory. Then uncomment the lines below and run the cell to load the models of your choosing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successfully loaded lenet\n",
      "Successfully loaded pure_cnn\n",
      "Successfully loaded net_in_net\n",
      "Successfully loaded resnet\n",
      "Successfully loaded densenet\n",
      "Successfully loaded wide_resnet\n",
      "Successfully loaded capsnet\n"
     ]
    }
   ],
   "source": [
    "lenet = LeNet()\n",
    "resnet = ResNet()\n",
    "\n",
    "models = [lenet, resnet]\n",
    "\n",
    "## Uncomment below to load more models to play with. Make sure the model files exist by training or downloading them.\n",
    "\n",
    "# lenet = LeNet()\n",
    "# pure_cnn = PureCnn()\n",
    "# net_in_net = NetworkInNetwork()\n",
    "# resnet = ResNet()\n",
    "# densenet = DenseNet()\n",
    "# wide_resnet = WideResNet()\n",
    "# capsnet = CapsNet()\n",
    "\n",
    "# models = [lenet, pure_cnn, net_in_net, resnet, densenet, wide_resnet, capsnet]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that there are even more networks available in the `networks` directory, but must be trained before loading them here."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate Model Accuracies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After loading the models, we would like to evaluate all test images with each model to ensure that we only attack the images which have been classified correctly. The code below will also display the accuracy and number of parameters of each model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluating lenet\n",
      "Evaluating pure_cnn\n",
      "Evaluating net_in_net\n",
      "Evaluating resnet\n",
      "Evaluating densenet\n",
      "Evaluating wide_resnet\n",
      "Evaluating capsnet\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style>\n",
       "    .dataframe thead tr:only-child th {\n",
       "        text-align: right;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>accuracy</th>\n",
       "      <th>param_count</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>lenet</td>\n",
       "      <td>0.7488</td>\n",
       "      <td>62006</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>pure_cnn</td>\n",
       "      <td>0.8877</td>\n",
       "      <td>1369738</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>net_in_net</td>\n",
       "      <td>0.9074</td>\n",
       "      <td>972658</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>resnet</td>\n",
       "      <td>0.9231</td>\n",
       "      <td>470218</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>densenet</td>\n",
       "      <td>0.9467</td>\n",
       "      <td>850606</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>wide_resnet</td>\n",
       "      <td>0.9534</td>\n",
       "      <td>11318026</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>capsnet</td>\n",
       "      <td>0.7982</td>\n",
       "      <td>12384576</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          name  accuracy  param_count\n",
       "0    lenet    0.7488        62006\n",
       "1     pure_cnn    0.8877      1369738\n",
       "2   net_in_net    0.9074       972658\n",
       "3       resnet    0.9231       470218\n",
       "4     densenet    0.9467       850606\n",
       "5  wide_resnet    0.9534     11318026\n",
       "6      capsnet    0.7982     12384576"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "network_stats, correct_imgs = helper.evaluate_models(models, x_test, y_test)\n",
    "correct_imgs = pd.DataFrame(correct_imgs, columns=['name', 'img', 'label', 'confidence', 'pred'])\n",
    "network_stats = pd.DataFrame(network_stats, columns=['name', 'accuracy', 'param_count'])\n",
    "\n",
    "network_stats"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prediction Function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the black-box attack, all we should care about is the inputs to the model (the images), and the outputs of the model (the prediction probabilities). No special information about the model is required; we could even swap it with a model that is not a neural network.\n",
    "\n",
    "Define a function that runs several perturbed images on a given model and returns the model's confidence (probability output) in the target class, one confidence value per image. If the target class is the correct class, this will be the function that we want to minimize so that the model will be most confident in another class (which is incorrect). Otherwise, the target is an incorrect class and we will want to maximize it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict_classes(xs, img, target_class, model, minimize=True):\n",
    "    # Perturb the image with the given pixel(s) x and get the prediction of the model\n",
    "    imgs_perturbed = perturb_image(xs, img)\n",
    "    predictions = model.predict(imgs_perturbed)[:,target_class]\n",
    "    # This function should always be minimized, so return its complement if needed\n",
    "    return predictions if minimize else 1 - predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below we can modify a pixel in an image and see how the confidence of the model changes. In almost all cases, the confidence will not change. However, for very special cases it will change drastically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confidence in true class bird is 0.00018887517\n",
      "Prior confidence was 0.7066183\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f91bb0c76a0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "image_id = 384\n",
    "pixel = np.array([16, 13,  25, 48, 156])\n",
    "model = resnet\n",
    "\n",
    "true_class = y_test[image_id, 0]\n",
    "prior_confidence = model.predict_one(x_test[image_id])[true_class]\n",
    "confidence = predict_classes(pixel, x_test[image_id], true_class, model)[0]\n",
    "\n",
    "print('Confidence in true class', class_names[true_class], 'is', confidence)\n",
    "print('Prior confidence was', prior_confidence)\n",
    "helper.plot_image(perturb_image(pixel, x_test[image_id])[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Attack"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we will demonstrate two variants of the one pixel attack: untargeted and targeted."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Targeted vs. Untargeted Attacks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The objective of an untargeted attack is to cause a model to misclassify an image. This means we want to perturb an image as to minimize the confidence probability of the correct classification category and maximize the sum of the probabilities of all other categories.\n",
    "\n",
    "The objective of a targeted attack is to cause a model to classify an image as a given  target class. We want to perturb an image as to maximize the probability of a class of our own choosing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Success Criterion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a function so that whenever a given perturbation is sufficient to fool a model, it returns `True`. This will be called the success criterion. The `targeted_attack` boolean flag will indicate whether success means maximization of the target class or minimization of the correct (target) class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def attack_success(x, img, target_class, model, targeted_attack=False, verbose=False):\n",
    "    # Perturb the image with the given pixel(s) and get the prediction of the model\n",
    "    attack_image = perturb_image(x, img)\n",
    "\n",
    "    confidence = model.predict(attack_image)[0]\n",
    "    predicted_class = np.argmax(confidence)\n",
    "    \n",
    "    # If the prediction is what we want (misclassification or \n",
    "    # targeted classification), return True\n",
    "    if verbose:\n",
    "        print('Confidence:', confidence[target_class])\n",
    "    if ((targeted_attack and predicted_class == target_class) or\n",
    "        (not targeted_attack and predicted_class != target_class)):\n",
    "        return True\n",
    "    # NOTE: return None otherwise (not False), due to how Scipy handles its callback function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we demonstrate the usage of the success criterion function. It's nearly identical to `predict_class()` as before, but also decides the success of the attack. For purposes of demonstration we assume an untargeted attack."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confidence: 0.07460105\n",
      "Prior confidence 0.5005429\n",
      "Attack success: True\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAO4AAADuCAYAAAA+7jsiAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAE8JJREFUeJztnVtvXOd1hteePechOZzhSaRIilR0sq3GSnVA7DaIEaQNisJtDk3R6/6C/pn+hPaiBYoCBZoABlzEQQOnSewodnS0ZVISKZLiecg57dl7epFe5GK9S7O3ZLQLfZ/Lb/mb2bM573zyevdaKxgOh0II8UXuf/sCCCHpoXAJcQiFS4hDKFxCHELhEuIQCpcQh1C4hDiEwiXEIRQuIQ7Jp/zv+ZgVIV8+wYv+g7TClZ9/8L66Xt79BO65vX6srn+0V4J7vnbjFozNL1+EsWQQw1gu0O9HANZfxNDch2PBK/79y3b1L9qIgtmuPeuTtZk/WwbMS8zwARIjhj7Xn95YHOm1+U9lQhxC4RLiEAqXEIdQuIQ4JHVyaqKg/y/3XG0A9/xyf1Ndn577OtxTLeFLC5IIxmrVCowNE5AuCPDvl5W4shInVirjVSdcMifXrNfMssl8r//7hkTW5FQy1O9WluTUqPDEJcQhFC4hDqFwCXEIhUuIQyhcQhxC4RLikNR2UCHQ0+L9U/15ZBGR5x19/bh1Avfcv4OffX7rG3MwVszVYCwZgueYwWcSEbGclsx2kPWicKPxihmv0QK+m/VTn+0SM2GbSxn/MoblY73fMNCNn9i6jpd0x3jiEuIQCpcQh1C4hDiEwiXEIRQuIQ5JnVUu5/TM7MDoPHEc62/zdPMZ3HPt8iqMjdfGYCwXwpDkQz2YtZDAjFodEzK/X/pddpeOTC+JMbPKrzav/GWULFiFEOZwPBAzM9HJy52ZPHEJcQiFS4hDKFxCHELhEuIQCpcQh1C4hDgktR20uXugrp+vT8M9y7P6+v37uMhgdv4cjJXKZRhLYtz7Kswjr8gqMsC/bTnQa0hEZGg2HLLeD8UsCwlfo2UHmYUQIGj3UMdR63ZYNkyG2/GC5uVZ+3NlsIOMLYlhW44CT1xCHELhEuIQCpcQh1C4hDiEwiXEIRQuIQ5JbQf9w7//Ql3/4fUpuOf6akNdf3CIc+LT08BDEpFCPpvtkAtQdZCxyWzoZNgY4SsfNJIpZHsS6ZtEmVU5xv0IzYs0zg/4mlnrg7Lex2zfA/hyL1nfxBOXEIdQuIQ4hMIlxCEULiEOoXAJcQiFS4hDUttBdx/11fV/fI5Hhvztd6+p6zeXS3DPGC4AktCaIG/YMDkwKsJuZGZZJlaVz5c3fiIVllVh/WxnsYPSv9wLo8g2yTz+5QV1SjBi2UHD9OdfYlYwvRieuIQ4hMIlxCEULiEOoXAJcQiFS4hDKFxCHJLaDhqCLlcfPQJj50XkzAe6VfQX37oB90TxIYwFwNYREQmsxmMwZjRiyzjnJ2vBEbQ/ss4AyjqzB9kVGT9Y5hlMGa7fbD6X8b1M8wY2i0vfYG5UeOIS4hAKlxCHULiEOITCJcQhFC4hDkmdVR7EkboeFHFVwL/+9L66Xh+vwj3Lr+NL2zrFGbmLF6/AmIDiBCthmzN/2l71ZHkj62m2SsrYR8m6DqOQA5Ek1gP8xntl2vTqizgydwkDhRzm68VZ3+x38MQlxCEULiEOoXAJcQiFS4hDKFxCHELhEuKQ1HZQuaLbPpXKHNzzaO+Juv7P79+Ge84/3oexXPVTGPvL7/8VjH31a3+oricxzs1bz4LnDK/IclMCq0cR8BDiZAC39Dq4wGMQ6T3CRESibhfGuu22up4P8bVXJ/EYmsr4OIyFIR5FAx/Ut1qBWe6Y8TdLjJEsuQzuk1nOkMFu+3144hLiEAqXEIdQuIQ4hMIlxCEULiEOoXAJcUhqO6hW09P6OSNffvHym+p63N+Ce27ffQRj5dIzGJucbMDY61f16yjksR0hOWvMCN4mMa6UOT09gLG9J+vq+vaDX+PX29mEsah9AmOdE2y57R8cq+tDwfcqbJyBsQu3vgljb337OzAWD8DYmEIB7skb38Wttc9grDG7AGPlWg3GkGU1tHpYJS9XHsQTlxCHULiEOITCJcQhFC4hDqFwCXEIhUuIQ1LbQd2uXjVSyBfhnvG6bhM0J5twz/7+NowdHmOLY/3xFzDWPtUtjnpzEu7ptFowdrKtVz2JiDy+/SGM7Xz2WxiLOqfqehjhz5zv6XtERFp7ezC2saffDxGRCFRMjRXwV2a3p4+aERE5uvNzGJONhzAUj+k2zMq1t+GevvHdeXAfv9db7/4QxkLDfiqC7/6z9TW4Z2vjsbp+/gffhXt+H564hDiEwiXEIRQuIQ6hcAlxCIVLiEMoXEIcktoOwi2wrGoYvZlZaFRPvH1Lb+wmInL3/gMYq4LqJRGRn/zHj9T1c2P4Njz52XswJi1c5dPuYqullMfWwnhdn6dUMAqYHu9hO6hoVKHML+BqmMqkfh/LlTG4Z6mHm8+d2bsHYzv/9vcw9qS+qK7vf4rttq3N5/g6/uQHMPaLD38MY1NNXPk0XtHtxF1g+YiI5AasDiLk/x0ULiEOoXAJcQiFS4hDKFxCHELhEuKQ1HZQPtS3BEbntDxouNY6jeCeONKrkEREms0KjF1a0e0DEZG7P/4Xdf15/xDumS7iayxXcEXUWB7/JjYn9flLIiLzM7oN82jjCO4Zn8Ize6qlaRhr9bElESf63/PoBFs+uWEPxvITuAJrfoArsPqTs+r64fYO3BMu4O9AL8b3cf02nknVbCzD2OIZPVavYessEjzTaRR44hLiEAqXEIdQuIQ4hMIlxCEULiEOSZ9VFj0r1x/gDFoAChCsER4nHfxUfQ/0jhIRuRjjzGYj0jPE7S08CqUDHrYXEZlu1mFspoKLLkrjOBsd5/WMeVLFNyuIjGn1fZyd7/Zwxnz/WL+PA9BzTERkZhwXT2wHeF+xOgdjO5F+tqzv4B5cq6vYdege4D5hwyG+H60j/B15HurXWA7Pwj3HJ7gQYhR44hLiEAqXEIdQuIQ4hMIlxCEULiEOoXAJcUhqO+jKRd0e+fBXeOxDsaTbJiFIo4uIlIrGWJAT/JD+2toajM0num2yOFaCeyZ7+HMdPMeWVbSgPxwvIjJdwUUB/Z7+4P8gwg+lV41+X4UEFwXsHWJb7fhAt29qZfyVmR7H1tlpD/+tH+cbMDZV0S2mfBF/rnFjevzYhN7TS0Skv4+LTfr4FssRKJaZjbFNl8vj79wo8MQlxCEULiEOoXAJcQiFS4hDKFxCHELhEuKQ1HbQjetX1fVPfvsZ3HPa01P6C3O4uiY00uU72/iyD4+xxTEV6L2vGsYIkinDB+ge4IqRg9gYyRJiu0IC/XNP1rAFVk9w5c2xYXFsgQogEdxb6mwd/81OA3yNp0Pc36oWYNukUtUtptoU/n50i/g8GubwvmqIr79cwvbkxJgea63hUTm1M3ikySjwxCXEIRQuIQ6hcAlxCIVLiEMoXEIcQuES4pDUdtDKygV1fWFuAu75/LE+uX3pLG4StruPm4Ft7TyDsdlpPCqiLaB6JcQT3cuCm7Tl+rq9JCKy9wxf49WFGRjbH9PvycYRtnyktwtDD5/uw9jjY9y07u/i99X195LvwT1Tgi2fM2M49qSPm7TtnuiW1XaMK6xuzOEmbfGwA2PNRfx32Xiif4dFRJ6d6N/V4BBPpH9tCV/jKPDEJcQhFC4hDqFwCXEIhUuIQyhcQhxC4RLikNR2UK2mWyrVMdwobLKup8uLRhXHZw/uwFivgy2Oau0PYOxgT597lGvguUcSYpurPMA20s4mbu7WOsJT0RcXFtT1u7vYxvjZJo7d2cN21o133oKxzWv/pK7nf4Tv1UQHV0sdBvirdu8EzxwK25+r653GCtzz5s13YCw3xLba/sZ9GNva+E8YW7mkW6TPnuJmgoFRiTQKPHEJcQiFS4hDKFxCHELhEuIQCpcQh6TOKh8f7KnrR8e4t1GY17OG2zs4u/po7QsYazZwpjc0fov2NvRp5IPFVbgnN4mzf5O5NRirbOB+ThvP8FiT+fMr6vrFGTxl/Te/wQ/AB1N6llpEpLk8D2OTDf39SnP44f6PP1mHMWnggpJ2hAsQEtD76vp13LMpauGii9NTXLzS62CXYHEBf+7Zpp5pH/RxnyrLURkFnriEOITCJcQhFC4hDqFwCXEIhUuIQyhcQhyS2g765ce31fXTNp4QjsZq7FoTwPv4YfClpSswdryLrZavBPr75dv4Ok6Mh9kLM3jMyOoZbDvstYx71dYtsqcHuGhh+vWvwtj33v1zGPvJhx/BWLer94G6fPkS3HN37zmMPexhO6sd4b/13IRutZy/gHuLVYe6ZSkikivgcSeTM4blMzUNY/2+/ppT03hcS3XMKGwZAZ64hDiEwiXEIRQuIQ6hcAlxCIVLiEMoXEIcktoOevKx3nvnbA2Ps9jq6m+zvY2tm1Ie9+uJTvDU+Z1NXKHyzgU9PT882IB7DgpVGGtO4D5bS/PYPogG2DZ5sv5UXe80V+Ced//mr2HszTf0fkgiIotn8TXevbemrt/7/BHc8zSuwVixiPtKSQlbXbmCvm/pHK56qk81YWysjy28XM6YZG+MogkCPTZM8GiVdqcFY6PAE5cQh1C4hDiEwiXEIRQuIQ6hcAlxCIVLiENS20FL6x+o65/HDbgnmrmprrda2NYZdHHFyPqdT2DsbAmn4M8Gul2x38Z2xLN7eBRKePUqjE028XTz5imuDvp0Q68quvXtt+GeNy7jZndRB7/X8iy2TZbmdKvovyawPfbw7j0YW6jhqpy8Yf0dJXplWWycOUkX/z2jCF9HYNlBQ2wjwT0JboI3jPF1jAJPXEIcQuES4hAKlxCHULiEOITCJcQhFC4hDkltB411dAunF+EZOxFwHaxZLckAp/RFcCr9UgNXcUwO9dc8NH6/LFvqYAdX+VQW8Wybch3PlJFTveJo6cJFvGeALbA4wTZGYFS8SG6oLl85vwS3rK4uwtjRCW6etzCNvztfaegWXmMS21JRjO+HZdEYt0qGot8PEZEAhPAOkeAlz0yeuIQ4hMIlxCEULiEOoXAJcQiFS4hDUmeV99t6Vu6ooD8MLiLSH+hZ4CTBmeN6Ez8AXzjegbG5vPFgd1/PNubHcO+lOhifIiJy2sKjS9pdfP3DHv7cjXm9l1JjagK/3tDKX+KY+eA8uI1JjK+9kMfvVa3inmT9PM4qF8f1PmHlKh5p0m1jJyA0zirQOup/wJ8tAfc/NI7FOMaFFaPAE5cQh1C4hDiEwiXEIRQuIQ6hcAlxCIVLiENS20F9YBNEVTx+otfvqOuxYS2UivjSYqNvUCfGOf041GPFKrYjxgpG8cQJfpgdvJWIiOyfYLui8Yb+oH5tHD9Un1hPx4sRC6x9+m96xZikfnYRjwX5+Ne/grF7W7gv1tSZP1bXWy1ctNDv9mBMAnxWVcvY+rPuVaulX38xj9+rA6zJUeGJS4hDKFxCHELhEuIQCpcQh1C4hDiEwiXEIantoONEnxB+HOF0+fNtfcp6DKqGREQi4/UiY19sVPPUwFT0PWPCfbePfZ2J5hyMFYzKm84QT2c/t3JOXS8aP7F9wx6zqlqsCewBsE2KeXw/vv72DRjLG/tuGV/DK1cu6a8X4Ooay94bGvussSCx8fcM8/r1d2LjO2B8v0eBJy4hDqFwCXEIhUuIQyhcQhxC4RLiEAqXEIektoNuA+ekVcTVDpWibtEU6nojMBGR6BRbNCWjUdhUFX+kLmrSZnQJqxRxVU6hgmO7m7oFJiIi1QYMnVmcV9cDq7GbUYlkVQ4lA9xYr1DQ9w16+O88XsJW3Le++Q0YyxkVTANgdUXGKJF2B1cbDYxxLWWj2V2nj69xe0+vVAqNfnBVo/ptFHjiEuIQCpcQh1C4hDiEwiXEIRQuIQ6hcAlxSOqc9MOWnp4/s4ytnaU5fTp762gf7tnvHMFYAVRjiIh0jGZgWz09pX9gTDAPqjg2lsf5/ns72M6qXH0Nxmbn9DlGvR62OKyKF2scTpLgapg+6Ao4NCqzrBlGYQHPDhoY9x99gGIBfwee7+JmcWubeO7UaxeXYaxszD4Kj/S/TWJYVvX6OIyNAk9cQhxC4RLiEAqXEIdQuIQ4hMIlxCEULiEOSW0HvXbtTXW92GzCPY3GhP7mIbYPjndx2r4d7cHYRhu/5tmaXr3SibAdUepha6F3jK+jvrAEY6s3b8JYGTS06/fxnKXQuI+WfRNFxoydnO7D5AyDKTRm5SRGdVNiNLSDhUOG1TIO/s4iIqtLszBWLmBbrVDEsckJvUosEHyNtaoxp2gEeOIS4hAKlxCHULiEOITCJcQhFC4hDkmdVX73+3+mrr/304/gnv0jvWBgegZn+OrjeiZaRGRzAk9Ff7r+AMYWmzV1PZAW3IO7SokkbTwVfWZ8CsYWmrhnVgLGVgyNB/GTIc4cD4zJ5wHIHP8upv+mW7/0Vn8riXFWfGhknIco42z0CatWcMa2amRzh0amOo7w9RdC/a7UjL5SOSORPgo8cQlxCIVLiEMoXEIcQuES4hAKlxCHULiEOCS1HTQ7rfeWKgTYdogjvSdPtYhT+uuP8QiP1iF+uD8KcG+giT/6jro+WLsH99SOv4Ax68H/1vYujO08xO/XXF5R14fG1PnQmCwvAfYdrDEew4H+2UKjv1XOKDIY9HFBQ2D0CcuBGLKrREQ6faM/F4yIFIweYtYEmAooQAiMez8wij9GgScuIQ6hcAlxCIVLiEMoXEIcQuES4hAKlxCHBNbYCIWXrGkghIyANTlGRNL7uC98QULIlw//qUyIQyhcQhxC4RLiEAqXEIdQuIQ4hMIlxCEULiEOoXAJcQiFS4hD/hsz7QlrY5aumgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f91b999c2b0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "image_id = 541\n",
    "pixel = np.array([17, 18, 185, 36, 215])\n",
    "model = resnet\n",
    "\n",
    "true_class = y_test[image_id, 0]\n",
    "prior_confidence = model.predict_one(x_test[image_id])[true_class]\n",
    "success = attack_success(pixel, x_test[image_id], true_class, model, verbose=True)\n",
    "\n",
    "print('Prior confidence', prior_confidence)\n",
    "print('Attack success:', success == True)\n",
    "helper.plot_image(perturb_image(pixel, x_test[image_id])[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Attack Function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we arrive at the attack itself: how do we find the pixels that will result in a successful attack? First, formulate it as an optimization problem: in an untargeted attack, minimize the confidence of the correct class, and in a targeted attack, maximize the confidence of a target class. This is precisely our `predict_class` function.\n",
    "\n",
    "When performing black-box optimizations such as the one pixel attack, it can be very difficult to find an efficient gradient-based optimization that will work for the problem. It would be nice to use an optimization algorithm that can find good solutions without relying on the smoothness of the function. In our case, we have discrete integer positions ranging from 0 to 31 and color intensities from 0 to 255, so the function is expected to be jagged.\n",
    "\n",
    "For that, we use an algorithm called [differential evolution](https://en.wikipedia.org/wiki/Differential_evolution). Here's an example of differential evolution optimizing the [Ackley function](https://en.wikipedia.org/wiki/Ackley_function) (if you're using Google Colab, run the code cell below):\n",
    "\n",
    "<br>\n",
    "\n",
    "![Ackley GIF](images/Ackley.gif)\n",
    "\n",
    "<br>\n",
    "\n",
    "Differential evolution is a type of evolutionary algorithm where a population of candidate solutions generate offspring which compete with the rest of the population each generation according to their fitness. Each candidate solution is represented by a vector of real numbers which are the inputs to the function we would like to minimize. The lower the output of this function, the better the fitness. The algorithm works by initializing a (usually random) population of vectors, generating new offspring vectors by combining (mutating) individuals in the population, and replacing worse-performing individuals with better candidates.\n",
    "\n",
    "In the context of the one pixel attack, our input will be a flat vector of pixel values:\n",
    "\n",
    "$$X = (x_1, y_1, r_1, g_1, b_1, x_2, y_2, r_2, g_2, b_2, ...)$$\n",
    "\n",
    "These will be encoded as floating-point values, but will be floored back into integers to calculate image perturbations. First we generate a random population of $n$ perturbations\n",
    "\n",
    "$$\\textbf{P} = (X_1, X_2, \\dots, X_n)$$\n",
    "\n",
    "Then, on each iteration we calculate $n$ new mutant children using the formula\n",
    "\n",
    "$$X_i = X_{r1} + F (X_{r2} - X_{r3})$$\n",
    "\n",
    "such that\n",
    "\n",
    "$$r1 \\neq r2 \\neq r3$$\n",
    "\n",
    "where $r1,r2,r3$ are random indices into our population $\\textbf{P}$, and $F = 0.5$ is a mutation parameter. Basically, we pick 3 random individuals from the previous generation and recombine them to make a new candidate solution. If this candidate $X_i$ gives a lower minimum at position $i$ (i.e., the attack is closer to success), replace the old $X_i$ with this new one. This process repeats for several iterations until our stopping criterion, `attack_success`, which is when we find an image that successfully completes the attack.\n",
    "\n",
    "<br>\n",
    "\n",
    "See [this excellent tutorial post](https://pablormier.github.io/2017/09/05/a-tutorial-on-differential-evolution-with-python/) on how differential evolution works in greater detail. \n",
    "\n",
    "We will use a [slight modification](differential_evolution.py) of [Scipy's implementation of differential evolution](https://docs.scipy.org/doc/scipy-0.17.0/reference/generated/scipy.optimize.differential_evolution.html) to utilize GPU parallelism by batching predictions together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "tlO00HlxbB0k"
   },
   "outputs": [],
   "source": [
    "# Run this cell if you are using Google Colab to see the Ackley GIF\n",
    "if in_colab:\n",
    "    from IPython.display import Image\n",
    "    with open('images/Ackley.gif','rb') as file:\n",
    "        display(Image(file.read()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "7rlzqXpqSgrW"
   },
   "outputs": [],
   "source": [
    "def attack(img_id, model, target=None, pixel_count=1, \n",
    "           maxiter=75, popsize=400, verbose=False):\n",
    "    # Change the target class based on whether this is a targeted attack or not\n",
    "    targeted_attack = target is not None\n",
    "    target_class = target if targeted_attack else y_test[img_id, 0]\n",
    "    \n",
    "    # Define bounds for a flat vector of x,y,r,g,b values\n",
    "    # For more pixels, repeat this layout\n",
    "    bounds = [(0,32), (0,32), (0,256), (0,256), (0,256)] * pixel_count\n",
    "    \n",
    "    # Population multiplier, in terms of the size of the perturbation vector x\n",
    "    popmul = max(1, popsize // len(bounds))\n",
    "    \n",
    "    # Format the predict/callback functions for the differential evolution algorithm\n",
    "    def predict_fn(xs):\n",
    "        return predict_classes(xs, x_test[img_id], target_class, \n",
    "                               model, target is None)\n",
    "    \n",
    "    def callback_fn(x, convergence):\n",
    "        return attack_success(x, x_test[img_id], target_class, \n",
    "                              model, targeted_attack, verbose)\n",
    "    \n",
    "    # Call Scipy's Implementation of Differential Evolution\n",
    "    attack_result = differential_evolution(\n",
    "        predict_fn, bounds, maxiter=maxiter, popsize=popmul,\n",
    "        recombination=1, atol=-1, callback=callback_fn, polish=False)\n",
    "\n",
    "    # Calculate some useful statistics to return from this function\n",
    "    attack_image = perturb_image(attack_result.x, x_test[img_id])[0]\n",
    "    prior_probs = model.predict_one(x_test[img_id])\n",
    "    predicted_probs = model.predict_one(attack_image)\n",
    "    predicted_class = np.argmax(predicted_probs)\n",
    "    actual_class = y_test[img_id, 0]\n",
    "    success = predicted_class != actual_class\n",
    "    cdiff = prior_probs[actual_class] - predicted_probs[actual_class]\n",
    "\n",
    "    # Show the best attempt at a solution (successful or not)\n",
    "    helper.plot_image(attack_image, actual_class, class_names, predicted_class)\n",
    "\n",
    "    return [model.name, pixel_count, img_id, actual_class, predicted_class, success, cdiff, prior_probs, predicted_probs, attack_result.x]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Untargeted Attack"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's look at one iteration of the untargeted attack. Here we will demonstrate a successful attack an image of a frog with the `resnet` model. We should see the confidence in the true class drop after several iterations.\n",
    "\n",
    "Try to see if you can successfully attack other images/models. The more pixels we are allowed to modify, the more likely it is we are to find a solution for any given image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confidence: 0.7792326\n",
      "Confidence: 0.7792326\n",
      "Confidence: 0.7792326\n",
      "Confidence: 0.58617187\n",
      "Confidence: 0.58617187\n",
      "Confidence: 0.58617187\n",
      "Confidence: 0.5463879\n",
      "Confidence: 0.5463879\n",
      "Confidence: 0.40215665\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAO4AAAELCAYAAADeELqnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAGnJJREFUeJztnXmUHFd1xr/qdfZNy2hfLAkbxxa2ANssARMbgp2wnvAgxBgIkJwswAmBkxxCgiEYAgcTCIeT+ABhX/JIwMFgg3GwAccYDAgLW7Zk7RotI2lmNPv0Vp0/qgVt5X1P3TOjsR58v7+kuvWqXlfX16/m3rr3RtVqFUKIsEg93hMQQjSPhCtEgEi4QgSIhCtEgEi4QgSIhCtEgEi4QgSIhCtEgEi4QgRIpsn99ZqVEGef6Ew7NCtc9KTmb5FOeX4GzjhzIeaZc2FVGq7GDe2nR2UhAkTCFSJAJFwhAkTCFSJAJFwhAqRpr7IQCwmLLsw26uDzHPv8uVXfCR8Hd7RWXCECRMIVIkAkXCECRMIVIkAkXCECRMIVIkCaDgdFkdsvrvrMj4VcJgDAfF+qaAFTMqoLHPuIyUeLotmuOXz+7N4+4xHJF+q7UnP9xrTiChEgEq4QASLhChEgEq4QASLhChEgSjKYAz4Pa+wty8N9iud6yZ6Ux5sbN1h25XR8HuJq1m2rZtJ0TMrrHeY2fkQ/lUrFud0XaUnNsQSUVlwhAkTCFSJAJFwhAkTCFSJAJFwhAkTCFSJAmk8yYNs94Q/2orivjs9sX8T3BQIyJHxT8oQPfGGdxfk8tbV3d1DbwOgotWUK7hPGUY6OiVGktrS3WJIntAN3iGMmzUM+K7u7qa3oucYjU2PUlkq5gzRxxnfrzu7GqpY9h/TekOw6ehIa5hj404orRIBIuEIEiIQrRIBIuEIEiIQrRIBIuEIEyLzVnJpNHwZfLsksy//4z0em6Jv5knSW2n67eym1rd68jtp+mp2ktm33bndun5jgsYqK51rFsee3ucrzYaKU+9tZt3kNHXPl+vOobeYXx6jtR7E79AQARysl53Zvu5DYY61wW7Xiu1aeE5L1L/INIhlFjaIVV4gAkXCFCBAJV4gAkXCFCBAJV4gAkXCFCJCmw0Fxyh17SHm82zRz6CyEfHxe+zI5X9YTe3pi32Jqu6ynj9rSwyPUlnnRBmor9bhDRTt/vIeOQaaVmnJpbpsp8KyixYvdmT7PuuoCOmbZjgluK/PQ03QvD6sNj55wbi955l71hny4zZfh5rtZeYjUc4PPMd6pFVeIAJFwhQgQCVeIAJFwhQgQCVeIAJFwhQiQeQsHnSs9b7yl0UjhtLYWXvRt40U842V9bw+1TR87TG27i0epbcvvbXLP43weMjlyfJDaCkUeNunpWU5ty1d3Obfnijzk032MF8G78Knrqe2RwhS1td/vtk1MTdMxKV9Yx1P9z9cLytfrh9p8BeZ8VQgbQCuuEAEi4QoRIBKuEAEi4QoRIBKuEAHSfM0p0gm8WuA1keavSlUj+Lq9u215j8dwtaeVSK+n9cexYoHa2pcsoba1m90JCKl1vPbV9p3bqG10bJjaVq3qp7aV69we88F93KtcTHMbIl5na1V7G7X15tud249H/HNFHo+tr/VH1fPiP2uFktjc42JP7auKry5WA2jFFSJAJFwhAkTCFSJAJFwhAkTCFSJAJFwhAqT5JIO8OyyRnnK3igCAiLxs7W3RcBYopN1u+0KBu+YHH9pNbYfAQ2DlJ62itrUXnU9tLTl3wkOplXek7+7jYZ3WNt4lvm9JLx/X7r41lq/hYyae2kltj37zLj6uzD9bVHR/NylPWId8zbWB3OhrSF+J+f1djckxPUkGvpBVI2jFFSJAJFwhAkTCFSJAJFwhAkTCFSJAJFwhAqTpcFCJ1GfKpHimTJq1fah6+4o3Mas6PO5+FieYLPExB0j4CwC2XP1Maut/Dm/VMdXJP3dMSimlwOti9bV5QhwRD2N0ZHioaGpqzLk9XeXHW/y8p1PbqKdG1MAPt1LbocPHicVzf3hugYrnniMlyc54UJoF5AkHVee4ZGrFFSJAJFwhAkTCFSJAJFwhAkTCFSJAJFwhAqTpcFCKFItjCRIAUCWudL/7ncM7gANpT1GvDpKFUsrzUFbn1RdT26I/fim1teQWUduKPM+GSZPPNjPB5ziS5i1NpmJepK03Wkxt5aw77HMiM0THTOT47bT01c+ntr4NvL1K6YPWbRj1dKSHJ8xYrVBTusLDN6z1DgCUWQeSHA8lVlqblt5j0IorRIBIuEIEiIQrRIBIuEIEiIQrRIBIuEIESPPhINJnp+Kp0JUuu13wvvyfVHoWHcABpCLugo+q7o9byfHMldVP+C1q6+pdTW3VSX5pC8P8k0+dcPfEyZb5mMwUD4FVhnjYZHRihNra+t3hrBWLeNZTnOfXEX08DNN5Hp9HlWQ+lUd5yCcLT58fagHSngJuRV+mD8kgizpa+Lkyc1szteIKESASrhABIuEKESASrhABIuEKESASrhAB0nyKAsleqZKsIQCoFtxdWSJPWCfyuMt942KPS7/S6p7HEzbzDKCWCR7yKTw4Tm3o5uGKUpFfq8mT7iJtUydZ0TRgwmMrTvM5ZtvbqS1XcId22ge66JgWz9001tNKbfHIDLVteYr7+v/k+4/SMaVh3gUo64lBVj1ZZ96GRCR0WSrxwnoZHqVrCK24QgSIhCtEgEi4QgSIhCtEgEi4QgRI80kGxPMWZ/mhooz7BfPIc3bfS9iRpx1EocTddatIbaNXvPp6Omb8EO/2PjPFPaXnbeigthHPC/JRt9vjPDrqTj4AgOEJXlcqn+Ju1I52Psfl6zY5t7d3ck/00R28HtV37nqE2ladz73Kr/mza53bo8q36Zgf/PcD1Jb2JAuUPdeq4kl6qZJ0mYi1JgEw1zVTK64QASLhChEgEq4QASLhChEgEq4QASLhChEgzScZEI95qYfX16kQN3s+LtAxkaciVeTpd1Ku8N+idee7QzsbL+Cd2R8emKK2Gc+L4qkU7yDf0cbH5VPu+kUTw8fomMlW3u6kq4vPo3fpMmprb+9xbu/p5ZM/mubhj8o4r0fV3sO/s9ZlbtsFT1pPx9x32y+oLa7yBIS4lV+rnkV91DYB9308PepOGAH89dYaQSuuEAEi4QoRIBKuEAEi4QoRIBKuEAEi4QoRIM1nB5Ht6XaeKVMquOMmcYqf3tsqosDDQaUct+W73aGW6ckTdMzhnTuorT3D6zn1r+atOlraed2mZ1zxMef2z938DD4P0j0eAEoRv5LjJR6iKR1y13QaO8S/5+3bdlJba8sBautZxMNx45PuUMvuXQN0TKnEa3q15nh2U6snW+rC83ldsvxKd+jsrm9/i44pTXratTSAVlwhAkTCFSJAJFwhAkTCFSJAJFwhAkTCFSJAmg4HRaTFRy7ND8WaqVc9ncMRebKDqp5u5J6CX60kZHX8IC9ydvDhrdR22RaeodLbycMmRU8RsdtvN87tQwd20TH5LM94mYj5NY5jPq47657/0QM8dHZw8D5q67/EHYoDgNY2Hh478Oioc/sD9++hY1IpHtbJ592hGwDIu2saAgBKnjYpl/zOZuf2X2zlWUoDe/j32QhacYUIEAlXiACRcIUIEAlXiACRcIUIEAlXiABpOhxUKbozUTKefj6pijtEkx7lLvasp5xWuszDKbEn1NJBsnJmhvnco7ERfq6Jo9S2tJeHHaY8YYfpcXdoanqazyPn6WuzaSkPjVQqPEPl8G53l/vdg7yH0bpL3b2ZAKBng6eje4UXadv2o0PO7ccO8X5Jbbleaot9/YE8HeTHhnjI8NiAO1MpVeLhtgwJqzaKVlwhAkTCFSJAJFwhAkTCFSJAJFwhAqRpr3KZeJXzpFM9AGQj94vu6WnuAU6Bu16z7dwLiRz/Lcq2dLq3x7y9RJ5lSAAYOriP2qplPv+MJyFjevKkc3tbOx+zop+/pN8xtp3adj/CX4I/MLbYuT2/cQMds+iCNdQ2NuNOFgCA44/yNi+HdrttafCWN6k09+YWYvf1BYDYF60Y4nO849avObfPnOSfudXXrL4BtOIKESASrhABIuEKESASrhABIuEKESASrhAB0nzNKRIOiqs8bFLNuesNRZ4QUksv77J+5bVXUdv0GO/cvnLVcuf21Lh7OwDkcjlqO7j159S27Xt3UlvbCv4y/syYO3Ghr4P/xk6PuduFAEDp2CPUlm3hIavzL3C3UJnq5SGf7Q/zFiSPPMxbuRzdd4TaBna7v8+cp5ZWpcSTV8oRT06oeJI/ivyQKE65Yzs5T+JNhoRIG0UrrhABIuEKESASrhABIuEKESASrhABIuEKESDNd6QvujMvymQ7AIBkw5Sr3P9+HglHAMDTnvYsatt2923Utri3zbk97fHM969xd0QHgJYyr0P0oztvprbBAm9PUsq7M30iTNAxl23imTIrO3g4q7WfX+OTKfcc7/jqXXTMnd/iIbCJ8TFqK5f4NY5IjCZX4hliUeypIZbxxHw8VKv8mLkKs3nqW1U9emkArbhCBIiEK0SASLhCBIiEK0SASLhCBIiEK0SANB8OYh5uTzgoVXFnT/jqZbVmubs/O8PPFY3zNhKs90dHeh8dsuUKHk45Os1tU2XenmRoOw8tPLhz3Ll99Voe8rlk6Wpq23WAF0fLLOXX8ZatP3Ru/973eYG5yozn2kd8jfA0J0E2Iu1rYh5CisHje54ONYg84ZuUJ/uNHdL3uc5kPRNacYUIEAlXiACRcIUIEAlXiACRcIUIEAlXiABpvlgc6aRdLfBQQKpIxnhCBPv27KG2Y4cOU1sm5S5MBwAndg06t6/YyIu3da7sp7ZymZ9r25G91Na3kneJv5xEHdYv41ktUYGHdY4P8a7zxWl+HXty7jk+eeN5dMzoSZ7BdOIkzw6a9Mw/rrqvcRwX6RjAk3kzy0bwsxnmG1Od7URqaMUVIkAkXCECRMIVIkAkXCECRMIVIkCa9iqnSe2dwgz38mWIVznlaUFy5DD3eN5+5x3U9uQL1lNbR8XdITyuuGtRAcCxYf5WemcLrx3Vl+Ue56EiT0BY1ue+Jr0t3BNdSHGv+DSfBgBufNLGjc7tyzvdSRAAMDTKvco79h6itvEivw9GSr3uMcP8/shXR6gtKnvak5Q9ySvUMjuqnnu/EbTiChEgEq4QASLhChEgEq4QASLhChEgEq4QAdJ8kgF7OXqKu9lZpxFfjR9fcaBtD22ntssvv4jaLtzU7dx+ZHKAjtm1+yC1ZUYOUFsfb9yO/mWe+ktld22pk9M9dMxkoZ3aMl2rqK23y9MKhdSPGj3pDqklNh4qasnx+lypNvf3AgAnRtzj0p4xUWmK2yr8Pk2nPOuYJ3qTYj1sfCGflMJBQvzGIeEKESASrhABIuEKESASrhABIuEKESBNh4NiEtvJF3j4pkLaSPiakGQ9UytVeBhpdJzXWMq1bHAbjjxEx0wNDVNbW8xbXQwO8rBDZzcPjXR2uLOAduw4TsdMl3hoYUn/CmrLZfjv9vSE+zoODfEMoHKJ18Va3OnO8gGAwzyKhExxyLm9EvNBE5N8jil4and5QjSRJ1QUZ9zj+Jn8kaJG0IorRIBIuEIEiIQrRIBIuEIEiIQrRIBIuEIESNPhoDJxY2c8rvRUizv8USnyruKsbQkAZDxZRffedy+1XbzBXQxs+RDPDlo/zcM6AyleZC7dvoTado/xYmaH9roLyQ0e5aGnrgpv73F8cJLaFi3lc0xlya1R5QXVurp4QbtihmciTYx44kEld1hqZswdJgKAyFP0zXefVvklBqmRCACIyf1Y8XSxn2s8SCuuEAEi4QoRIBKuEAEi4QoRIBKuEAEi4QoRIM1nB5FMn6rHzZ7pcBdAK41zt33K06XcV7jryCTPovn6Az92bn9pF3fbt6fdRdMAYPsAz0TKxnySk+08NPLQhPt81RQPtfS09lHbxLET1Dayh4fBlq52ZxUt6uSF6VJ5Hh4b4pE/jEzzcNDomHv+5YLn2tNsNH+NtornxvJFdqqx2xil+fFiFYsT4jcPCVeIAJFwhQgQCVeIAJFwhQgQCVeIAGk6HJRmLvMyL41VJNkaVU+GBC8jB1TynqJeK3lIYivJQmkb55fhaUvz1JbKF6ltx053lg8AlNYupbbMkpXO7UOPHqNjhtO8V86G9byJUTzNYzRRPuvcnmnl4aA430lthw/vp7YTQ7wHU6nkLvyW8dy5sSeVxxvy4YecVTJP5DlXPMclUyuuEAEi4QoRIBKuEAEi4QoRIBKuEAHStFeZvRsdebzKccntVY5SvMhPnOZJBukl3HNc6uXtPYoTbr/h1nFfSxDued28hneJHzzOO7fvHOXe6LYetz89m+LzODw+SG0r+njn9pWLeFuQInlRP9fJExoODvNkgX0De6ktinnLkGyr+4arVn1rjqddSNnnO/bEMjxu5SpLvPHWqZobWnGFCBAJV4gAkXCFCBAJV4gAkXCFCBAJV4gAaTocVGhzaz077nFwk0hR3MrDMBVPOKi1n9dsyhY9ta8qbluc5/N48AgP3Vy0no97Qj8PWe0t8steIa0/0p5rNTHKQ097R3m7E1+yRmHaXftqcj9Pnth3jIelChXeCiVDOroDQET6ghQzfM3h3xiQ9bS2qXjiN1GWn88XYKLHm9WoX6EVV4gAkXCFCBAJV4gAkXCFCBAJV4gAkXCFCJCo6uut8P+Zmw9bCNEIZ6xw1Wwcd24NT4QQ84IelYUIEAlXiABp+pVH8euBMaYNwFcAPBPAbdbaP3ycpySaQMJdIIwx9fVZ2gAU8Ku3uP/UWvuFBZ7SywH0AVhkrfU0IxbnIhLuAmGt/WVnamPMPgCvt9beyfY3xmTOsqDWAtjBzrEA5xdzoNlwkJgHXMI1xrwHwCYkdcR+H8AbAVwNYJe19obaPlcD+IS1dl3t/6sAfBTJ4+4EgA9aaz/WwPlvBPA2JFGCAoC/AJAFcD2AnwO4DsC/AHg3gHcAeB2AVgC3AXiTtXasdpzXAngXkieIDwH4cwDXWWvvns11EY0j59S5xUsAfBFAN4D/8O1ojEkD+AaA+wGsBPBcAG8zxlxVsz/bGHPCNdZa+3cAPgDgC9baDmvtZ2qmpwN4GMASAO8H8HokIr4SwAYAvQA+Ujv+xUjE/Yra+ZcAWDabDy2aR4/K5xb3WGtvrf172hjj2/cKAF3W2vfW/r/LGPNJJEL6H2vt9wAsbvL8B6y1/1p3/j9CsorvBQBjzNsB/MwY8zoALwNwi7X23prtHUieEsQCIOGeWxxsYt+1ANYYY07WbUsDuHsez78CQH2bvf0AckhW1xX1+1trJ40xPGtfzCsS7rnF6Q6HSSR/P56i/lH0IIBHrbVPPIvnP4zkB+IUa5AUmDgO4Ei9zRjTjuRRWiwAEu65zc8B/KUx5n0AWgC8qc72QwBFY8xfA/gYgBKACwHkrLU/nafzfwnAW4wxdwAYAnAjgC9Za2NjzFcA3GOMuQLAz5A4ssQCIefUuc2nkTiL9gP4FoAvnzLUQjXXArgMwD4AJwDcDKALAIwxV572GD0bPo7ESfYDAHsAjAN4c+382wD8FZKXOA4jEfYQEi+1OMsoHCTmBWNMF4CTANZaa5v5W13MAj0qi1ljjHkhgDuRPLndBOBnEu3CoEdlMRdeguQxeQDAOgB633mB0KOyEAGiFVeIANHfuOcYxph1APYCyFpry8aY2wF8ue61xLN13hsAbLTWXjfL8VUAm6y1u+Z1YsKJhDsLakkC/UjS8iaRvHz/Rmstb60+S6y11zQxJ2/Gkfj1QY/Ks+cFtVS9LQCeiiSL5jEYYyJjjK6xmHe04s4Ra+2h2uPsRQBgjLkbwP8iyajZAuBiY8xxJGlv1yJJ2/sUgHdaayu1LJ/3A3gNgDEkYZVfUjve5621n6j9/w0A3gJgFZLXHq9D8iLEGgC3GmMqAN5trf1A7a2mDyF5o2o/gDefSrkzxqxH8oLHFgD3AdjRzOc2xrytNo8qTvvRMsZ0I0k3vAbAFJIXOd5be+MqjSQz6dVIXui4qbZvVvm/jaPVYI4YY1YjEeTWus2vAvAnADqRCOYzAMoANgK4FMDzkKTMAcAbkOTfXgrgKQD+wHOulwG4AUnebBeAFwIYsta+CsAB1J4CaqJdCeCbAN6DpNLFWwH8lzFmSe1wXwTwUyQZRP+IREj159pmjHklmcfza8d7LpIc4qtP2+WjSFITzwPw7Np8X1v3ea8BcAmSH40Xs88rOFpxZ88txpgygFEkAnlvne3T1tqHAMAY04/kRu2x1k4DmDTG/DMSYd8MwAD48KkXF2rvJV9Jzvl6AB+w1t5f+7/PEXQdklpSt9X+/x1jzE8AXGuMuQvJ4/3V1toCgO8bY26tH2yt3ew5tgHwKWvtg7U534BaDLe2or4cwKXW2nEA48aYm5D8mH2yNvYj1tqB2v7/BOAqz7mEAwl39rzY4wiqf3toLZLqEkfq8mtTdfusOG3/+jS601kNYHeD81sL4GXGmBfUbcsCuKt2zhFrbX3T2v214zfCCiSrdf3YUyxGkvp3ejrgyrqx9Z9Xb1rNAgn37FD/VstBJC/eLyZ/wx3BYwWzxnPcg0gqUZzpnKf2/Zy19g2n72iMWQug1xjTXifeNY5jMHxzPoEkU2ktgO119kN1Y1fV7d/oj4WoQ8I9y1hrj9TS4m4yxvw9ktpQ6wGsqlWpsADeZIz5BpLQ0t96DvcJAB8yxtyDJJVuA4CStXY/gEEkf1Oe4vMA7jfG/C6S94mzSKpm7LLW7q89Nr+rVtXiMgAvAPD1Rj8WgE8ZYz6LJDPpnXWft2KMsQBuNMZcj+Tv67cA+GDd2DcbY75Z+7x/0+A5RR1yTi0M1yN5fNwOYATAfwJYXrN9HMC3ATyARIxfZQex1n4FSU7sF5F4ZG9BIgwAeB+AdxhjThpj3lr7m/lFAN6OJPH9IJICcae+81cCuBzAMBLhfbb+XMaYh2qla1zzuB3AhwF8F8nf2d89bZc3IhHlHgD31Ob773Wf9w4A25A49G5D4rirQDSM3lUWjyvGmGsA/Ju1du0Zdxa/RI/KYkExxrQCeA6SVbcfyWr/tcd1UgGiR2Wx0ERIajGPIHlUfhjAPzyuMwoQPSoLESBacYUIEAlXiACRcIUIEAlXiACRcIUIEAlXiAD5P3jDJ6my4z4FAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f91bb0c6d68>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "image_id = 102\n",
    "pixels = 1 # Number of pixels to attack\n",
    "model = resnet\n",
    "\n",
    "_ = attack(image_id, model, pixel_count=pixels, verbose=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Targeted Attack"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the targeted attack, we can choose which class we want a model to classify an image as. The task is much harder for the targeted attack, as we constrain the misclassification to a given class rather than any class that's not the correct one. We should see the confidence in the target class rise after several iterations.\n",
    "\n",
    "Below we try to cause the `lenet` to classify an image of a `ship` as an `automobile`. Try to change the parameters and see what happens."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Attacking with target automobile\n",
      "Confidence: 0.072408296\n",
      "Confidence: 0.072408296\n",
      "Confidence: 0.072408296\n",
      "Confidence: 0.072408296\n",
      "Confidence: 0.072408296\n",
      "Confidence: 0.072408296\n",
      "Confidence: 0.072408296\n",
      "Confidence: 0.104250394\n",
      "Confidence: 0.104250394\n",
      "Confidence: 0.104250394\n",
      "Confidence: 0.104250394\n",
      "Confidence: 0.104250394\n",
      "Confidence: 0.104250394\n",
      "Confidence: 0.104250394\n",
      "Confidence: 0.28965676\n",
      "Confidence: 0.28965676\n",
      "Confidence: 0.28965676\n",
      "Confidence: 0.28965676\n",
      "Confidence: 0.28965676\n",
      "Confidence: 0.28965676\n",
      "Confidence: 0.28965676\n",
      "Confidence: 0.28965676\n",
      "Confidence: 0.28965676\n",
      "Confidence: 0.28965676\n",
      "Confidence: 0.28965676\n",
      "Confidence: 0.28965676\n",
      "Confidence: 0.28965676\n",
      "Confidence: 0.30170715\n",
      "Confidence: 0.42491597\n",
      "Confidence: 0.42491597\n",
      "Confidence: 0.42491597\n",
      "Confidence: 0.47848365\n",
      "Confidence: 0.47848365\n",
      "Confidence: 0.5053054\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAO4AAAELCAYAAADeELqnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAHWlJREFUeJztnXmQnVd55p+7dt/bq9Tad8nyInYcJ2ZcJBgwxBAgQ1U4yRAgAUySqYIwMwljw0ABCYFKWKtmUikKEtYAOTOZosLmkDCGxE5sbLwgtS3LVltSS62lW72p++7L/PFdkUY5z6t7ZQM60vP7x9Z57/m+c7/7Pfe7/b7nfd9Uu92GECIu0j/rBQghekfCFSJCJFwhIkTCFSJCJFwhIkTCFSJCJFwhIkTCFSJCJFwhIiTb4+u1zUqInzyp872gV+Hiyx/+VHC8Ua/TOZlMJjieyvAHfqFYoLZisUhtzWaT28gaN65aw9fR309tJ6enqa0Kvo7jxrxH77w7OH7dq15C56weWUVt+Sa/xu1si9qGcuFbo1LhcxZLDWprGltrW20+r7+QC46Pja2mc/ry/P5YWDxDbYvL3NY0nlmpVPizbjWqdE67Hb6Ov/LG19I5K9FPZSEiRMIVIkIkXCEiRMIVIkIkXCEipGev8tBA2NvbbnPva6sV9qBV2tzrXTGWVi1zD3ajwT2UGeLoXVzgx6tW+HdbrRr2lgNAJsPXvzw5QW3FSik43l/h76syyD295XKZ2lINbquDHZO/r3orT22lFr+OGctjSzzOp+un6ZxmZpbayvUatVUahs2YVy+FP7PqcngcAFotHnXoBj1xhYgQCVeICJFwhYgQCVeICJFwhYgQCVeICOk5HFQthTdiLy4s0DkDg4PB8XYf3wxeNkI+lUqF2qxwENnXjanZOTqnZeRD1at8E3mfEeJIn5yktkIlHKI5eP8+Omd29TC1ZVr8eoy0+TVO18OhjKUl49pn+efZzofvAQBo1/h17CcRwyJJggCAJo9KYam8TG3zRpLB/JlFals4PR8cLy/xcBDjbR+4ravX6YkrRIRIuEJEiIQrRIRIuEJEiIQrRIT07FW+4zu3B8dnpmfonFw+7ObL9HH3X9XwDpdKfHO85VWukxI680ZCQNXwymaNJImBBt9Efl2Jl64ZTIXL0Bw8xjfVHzO8yhs3jFHbVau4pzfbDF/jQ4cO0zmlGvekj67m5YGKRgmjI1NTwfGsUaKo0eb3R7XOPdjVplFCZ4B7zHPk+Vevcq990SjN1A164goRIRKuEBEi4QoRIRKuEBEi4QoRIRKuEBHSczjo0Ud+GBzPk5APALTITv1GjW/CbhpV4Gs17mavG7WB2plwVfxmcYDOKQzxMEA/eM2pVU0eKlpnbJCfWghvdN+467l0znNf+IvUtmPnJmpLnz5BbQf23kttjNFhfq22rOqjtmKaX8f06fC9k2MZIwD6jPpWjTy/9o0W/8xG1/CQW7sQDu3MV/g9PDTMj9cNeuIKESESrhARIuEKESESrhARIuEKESESrhAR0nM4aPXIUHC8aGRP9LPm0HWjPYZRD6mvj4cW6jUeDsqnwuGgYs7I/BjmGTSFNv/eW82XgeEl3iLjaS+9ITi++Vre2Lq1bi21lWpGHaWFcK0kAMiR5tA7d19J5wyP8BDHOtKgGgCW5njm0/qN4ayilBH2W1swWqEsL1Fb2ah9NTTK31uD3I/9RCtPBXriChEhEq4QESLhChEhEq4QESLhChEhEq4QEdJzOGj3rm3BcatI28jISPjkGZ6NUTe6g6fA55VKvMXEWDHs0i80+ffXshGWylV5hspAiq/x6j3PpLb1r3hFcPyxGV6IbX4yXFANAFoZvsYlo8t9pi+c8TI0wIucNZv8XMtGIbmTizws2MqFz1epG0UBjXMtGq1tak0+r3L0FLU1yH18xmiVkyGFC7tFT1whIkTCFSJCJFwhIkTCFSJCJFwhIkTCFSJCeg4Hje8LF4tbWuJZF3mWzZMzsnyMVvANoy9P0+gpM0oKdKWMsNSZptEt3SgIt6NNMqIAXLF5C7UdnA1nDk1XeBhmMM0zb+pmOIiHRqbnFsLHa1ohDv55LqS5bfoMD+2cnCYF7dL8/nj6nqupbXT7bmq76567qe3xJ45QW50UL0zxJaJICsx1i564QkSIhCtEhEi4QkSIhCtEhEi4QkRIz17libmwVzFF6jkBABphz6a1Ab6VsjZh8++bbJZ768rV8DFbhle5leHtSfqMjeJ5Yx21DZupLZMJ10vqzxnfsW2+fishI5M3vPrt8K3RP7CKzskZUQJk+K22fnSU2q65IdxeZdNW7pnfujOcCAMAmzdtoLYbJg5S2yc+9nFqOzo5GRy3OtKnsz1L78fnP6nZQoifCRKuEBEi4QoRIRKuEBEi4QoRIRKuEBHSs0+6sOWq4LhVQyeVDock0samdOs7JW2cK2e42bNkXt44V7vNd4pb73mwyNuapK7Zw22km3rWqMHVMJIM2sZm/DXreeuS1WMvCo4fPXyIzmkZ9bmaWR6W+g/Pv5HaTs6Gkx3u+v59dM4/3PN9anvxC36J2m5+EV/HW//z26ntsYMTwfE7/vlOOuf4DK9h1Q164goRIRKuEBEi4QoRIRKuEBEi4QoRIRKuEBHSczgol+fdvhkp0o6j1eLZQSnjKyVlGNvgx2yzLJo0P14mw22Dg7xbfZaEwABg4uhRatt1Ben4njXCY2kjBJbntg2beThozVg4Y2fbdp7ZND4erkcGANU2/1y+9JUvUdvDB8Khlh27yXUC8KIbwxlFALB723ZqW5o7Q23PecazqG3PnmcEx/sGeUf6z3zh89TWDXriChEhEq4QESLhChEhEq4QESLhChEhEq4QEdJzOKiPtBOp13lmCD25EYZJG8XismkrO4hnyrDMoYzRPb6/j7cSWbt2DbW1jfDH5p08JNE3FM4qShX4tSoaBdwK5HgAgDZv/bFUXg6OP/054dAHAGzavona5s4sUlupxjOfbnjBjcHxn7/+er6OVaupzXpSZY17rrIUvh4AMHnkUHC8ZryvYlEtSIS47JBwhYgQCVeICJFwhYgQCVeICJFwhYiQnsNBrON72gjtMPI5nmmUNjKAskZBuP5+Hr5hoR0zRGCEl4aGeHbQ9DQvBrZq43pq27RhY9iQ4teqOMCzULJ9fP0Zo4BblkRG0kborLBqmNrWVngn+x1X7KI2lkCWMu63vraR7WX0WZqdPk1t99xzL7XdcdddwfGp2Rk6p9nk4cJu0BNXiAiRcIWIEAlXiAiRcIWIEAlXiAiRcIWIkJ7DQSzsY4VoWP+ddiscWgIAcK890uD9cAYKPOtizdhYcLxcLtM5VobH+Pg+aisUeFgqk+chmrEN68JzMnyOcalgXGEYkR2wWnfNJs8oqi/zkM/S0hK15XL83ikWwtlNGSMclCrzTLXHxh+htu/e+S/Utm//AWrLkj5RGzeS0B6AUq1Kbd2gJ64QESLhChEhEq4QESLhChEhEq4QEdKzV5l5iK12ImxO1nBr5ozWH1s389pGN7/sZmpbv35DcPz+B+6ncz77mc9Sm5VYcettt1LblXuu4sdku/tJcgcAwKiVZHmOW3V+zHI17Gmvl0t0TttY41BxgNr6+oy2No2wV3/m2HE6Zf8De6ntkf2PUdtyjd/Du6+5htrmS+F6VFMnTtA51Sr3wHeDnrhCRIiEK0SESLhCRIiEK0SESLhCRIiEK0SE9BwOqlbDm6MzGR6SKJJN2EPGRvzNxgbtN735zdT2rGc/k9pS+fD31I6d2+icb33rG9RWqfCN4jt38TYj6Qv4vkwZiRXtBt9U32jwEE21yhMo2DELOZ7skB/mNadSRh2o2uI8tR18ZDw4vvfBB+icRpVfjy1beShxvsqv1fjEYWp7fOJQcHxmhtecKivJQIjLDwlXiAiRcIWIEAlXiAiRcIWIEAlXiAjpORxUIDWdckaYIEdqLPWT7vYA4F7za9RmhXzaRtikVQvXSxpbxzuY3/SSm6ht716ehbLD6DqfM9qatGrhUEarzkMcbaMuVhM8TFcgLVkAIDvAOtkbWUpGm5ETkzybZ98D91HbzPGjwfEtpDYXABSGeFjqsclj1Hb3Xl6Pat8TR6jtzGI4OyhrtNFpGPdpN+iJK0SESLhCRIiEK0SESLhCRIiEK0SESLhCREjv4aD+cDioP89DO2nSz+Laa3+Ozvm5666jNivkkzIacqRI5TTLMf+Lz38+tY0aYQcr1FJe5gXXMmSN2RZfZSbHi61ljdCT1bqkXQqvcX52ms6ZOMDbdEwa4ZRCnt+G11x1ZXC8WuYtTX5w/w+o7d59D1PbxKk5apurGx3kW+ErmUoZ96lRDLEb9MQVIkIkXCEiRMIVIkIkXCEiRMIVIkIkXCEipOdw0HA+3ANmoJ+Hg0ZHw2GTX76Z9/nJDvDO8iysAwCpNnfbN0nhtHabH2/7pq3Utm443OEeAFDl60jlecZOLhP+SNJNI7RgrB81nrFTmeOhncmJieD4xBPhcQBotXjm0KaNa6gtZ/QOOnT4UHD8wYcepHMOTvDQ01yJX49Mlq+jkOZhtRrL3DLijJmMFYw7P3riChEhEq4QESLhChEhEq4QESLhChEhPXuVr7pid3B89cgQnfO0a64Ojl955RV0jtXhvmbUNkIrXFcKANAmbr4U9xgWaO0lYHiIv2erW302b3jFG+R9N/j7OjMzS23HDu6ntunjk9TWJN3l14zwxIp+Uo8MAI5Pn6S2+x/kHuKjJ8O1qhaXeJIBjGu/fsMGalsybp3GGZ4YAhLlsBzHbXYvdomeuEJEiIQrRIRIuEJEiIQrRIRIuEJEiIQrRIT0HA7avTscDtqwhrfxuIJ0Zy8tnOEnyvGN+Bmjlk/e2MCfJS1P2kabjkya21JGyApGjahmiYcyZk+cCI6fOMQ3zp+eCs8BgEyar2N4mIezXv27twbHP/+Rd9M5D+39IbUdneKtPyp13kKlP082/g8O0jkjIzyhoWJ8ZKWZeWpj4TEAqJEWMO0mjy9lMvy+6gY9cYWIEAlXiAiRcIWIEAlXiAiRcIWIEAlXiAjpORx09ZXhcNDIIM+iGSiGbXmj9US+aHRLz1qudKNjOsvWIC1SAKBthCrKizycNXvqFLWdOPQ4tc2dCmfR5I2Q1epBHtYpDvHPZdEIS33wv7whOP79799N55TLZWqzMqn6G6RmE4BSrRocX2d0pEebZ3udOmKEpSrhcwFArcbXyEJFKSMDyMp+6wY9cYWIEAlXiAiRcIWIEAlXiAiRcIWIEAlXiAjpORy0c8e24HjKKNI2OhbOHMoYbUaM6AfQ5K55NHj4prYUDt8szy/QOTMneFjn1HGelVNZXqa2Yr/R8mR9OMyRT/OPanGWd1If38tDT4eP89AIC+2sXbuWzlm7jttOGeExq1fH9m3hFjCkCTwAYN84f895lm0EIJvl945FPhcOP2WsMKOKxQlx+SHhChEhEq4QESLhChEhEq4QESLhChEhPYeDZohbf8gI7bRIhketzLNrlpYWuW3uNLWVzvCCX8sL4bBPqspDWVmaUgSsLw5QW7+RDVNp8yya06fCIaaTRuhp5hTvLN/M8Y9406ZN1Db+wWcHxzNv/xc65+RJ3h+oL8fDMBu28HW0SUhl38OP0DmFAs8s6x/mRQ0Pn+T3VcPo3dQgReGMaBD6+/kau0FPXCEiRMIVIkIkXCEiRMIVIkIkXCEipGevcqUS9oi26rxL/NThieB4vca9q806r/9jlZzqzxrdyEk39aKxgT/V5LWBlhe45/vo5GFqOzTDN/fPLoS94oV+7rW3vLJjRgf2eaOr+9pb/j44fuwY99qvMxIQNm7YSG1NY8P93kfGg+PpFP9c1oytp7aS0XW+VOJd59tGIkSjQeqctXn9sxTpYt8teuIKESESrhARIuEKESESrhARIuEKESESrhAR0nM4KEc6aTeNcNDycjiZYN3YKjpnbISHOIyID9oNHkYqL4fDH9MLfJP+1JFJapudmeELMTrSF1aNUtt1e64JjvcZm9Ln5nmI5oG9D1Hb6Vm+/r6+vuD4Fbt30TlrxsaobX6ab+B/+MCj1JbtCycnbNzAQz59gzyR4Mj4AWozu8S3eRwpT9ZodaRXOEiIyxAJV4gIkXCFiBAJV4gIkXCFiBAJV4gI6Tkc1CIubsuVzrJGWlWejTE3w0M0LaNLfKHPeEvpcEZJu8jnbNnDwx8701fyU7W5u39uiWdFPT7xRHB8copnFC2XeLuTQp53Z9++fTu1rV4dDqksGRlF+/bupbbSIq8vNkKytgBgjLQ16SvwbKlHJ/i1mjo+RW1m1/kWz/RpkdBfy2iVk04/uWemnrhCRIiEK0SESLhCRIiEK0SESLhCRIiEK0SE9BwOyqbDYZ9shn8HpMicWp1nT1QrPMSRN9pZZI0smuHRweD46jwP3ZRLPHRz5IlD1PbIww/zecd4uIKFHd7jePjjq4/uobYB43osL/Jid/v37w+OzxgZUbkMv502rl1HbZu3baM2ZMPH3DvOr+/UAg8XzizycNaS0Yomk+FhtUYjfL5mk4eQymV+X3WDnrhCRIiEK0SESLhCRIiEK0SESLhCRIiEK0SE9BwOGugPd2G3OnbXmqRwWpaHKlLhWmXJ8YzCXWcavKdMdT4cCqgu8cyVI0eOUJuVDdM2+uGsXceLma0nRdC+cyx83QFg6cxxarvvHl6IbWGeh4NGRkaC4xs38iJ+69asobbR4fDxAOD0LC92N/5ouLhbKsdvkMnZBWqbKfFigizLBwBSrD8Q+L1v3QOWrRv0xBUiQiRcISJEwhUiQiRcISJEwhUiQiRcISKk53BQjbi+KxXeO4hlQtTKPFOjVuXZQQ2jP9DgUJHa+vLhLKW507ww3ewCD1W0jYyoao2vcanMs1fmHpsIjlvXd3mZX6uskdWyY/fV1LZmbTi0Y/W8mTbCS/sPHKS2OSNjp68YzuhaMgruPXGIh/CqTR4uZP2SALu4Wz4fzlazrpXCQUJchki4QkSIhCtEhEi4QkSIhCtEhPTsVT45fSo4btXXqVbDHtbKEvdCLi/NUVvd8CqPVMNeSACYXwgf8+gx7oU8fZp3Uj91inujU2nuUWyljM3nZNxq8ZLLcc8x2tyDfWKWJ1fkJ8N1sUol3jamZHi3Bwrc279qdbjNCAAsVsP31YGJSTonbdS+Gujn18q6xlYSTavFPdVP5ZyV6IkrRIRIuEJEiIQrRIRIuEJEiIQrRIRIuEJESM/hoMNHw254y13O2mo0ykYiQY1vIp+ZOcnnGaGioyfCIY6TszysU6/zruKVCj9XtcqTAipG5/M+0jJkcJCHuawkgxMn+XvLkPYeAFAshsM3qRT/ru8nm+0BoJjn12Nqlq+/2ggHyCpG+5p+snYAgLHx3wp1WUkeVjIBQ0kGQlyGSLhCRIiEK0SESLhCRIiEK0SESLhCREiqR7f0k/NhCyG64bzxpV7juL0HrIQQTzn6qSxEhEi4QkSIhCt+hHPuJufcIcP+aefcu36KSxKEnvcqi95xzq2s+F0EUAVwdgP373rv//qnv6re8d7f8rNeg0iQcH8KeO9/lCHQeaLd4r3/R/Z651zWe8930YvLHgn3IsA59wEAVwJoAXgFgLc5524C8Lj3/n2d19wE4NPe+x2df28B8D8BPB/AEoCPeO//vMvzvQLAhwFsAbAA4KPe+4+vsP93AO8AUAdwm/f+853xL55d09n1APgrAG8HsAjgnd77rzyJSyG6RH/jXjy8GsCXAIwA+Bvrhc65DICvA7gXwGYALwHwDufcizv2FzjnZoxDfAbAm733QwCeBeB7K2xbABQAbALwewD+wjk3TI6zBcBQ57VvBvBXzrnd1trFU4OeuBcPd3rvv9b5/7Jzznrt8wAMe+8/2Pn34865vwTwGwC+473/HoBw166EOoCnOef2eu9nAcyusFUAfMB73wTwd865KoCrANwXOE4LwHu991UA/885dzuA1wD4kPlOxZNGwr144IWC/z3bAWxzzq1sJZgB8N0u578awP8A8GHn3EMAbvXe39OxzXREe5YSAJbFf9p7vzL7/DCSp6/4CSPhXjycu510GYkH+iwbVvz/JIDHvPd7LuREHZG+yjmXQ/L36VcA7LyAQ4055wre+7PlSrYh/GQWTzES7sXLgwDe6pz7EIB+AL+/wvavAGrOuT8A8Ofo/PQFkPfe/8A6qHOugOSJ+3Xv/aJz7gz+LTTVK2kA73POvQfADQBeBuC2CzyW6AE5py5ePgvgESQ/P29H8lQEAHRCRS8H8AsADgGYAfBJAMMA4Jy78Zyf0efyWwAOO+cWkTiVXn+BazyK5JfBcQCfQxLmeuwCjyV6oNfsICEA/PvwlPjpoieuEBEi4QoRIfqpLESE6IkrRIQoHHQBOOd2AHgCQM5733DOfQvAV7z3n/sJn/d9AHZ771/3kzzPz5Jzr23A/i4Au7z3t5zvtZcyl6xwO1k465HEKJcBfBPA27z3S9a8C8F7/7Ie1mRmBl0MXMyCWLHN87LmUv+p/MpOSt21AH4ewLvPfYFzLuWcu9Svg7jEuGSfuCvx3h/r/Jx9BgA4574L4C4ANyIR9TOdc9MAPoZkY0MLSQbNe733zU42zp8C+G0k6WsfXXn8zvG+6L3/dOffbwHw35Bkz0wCeB2A/4pkS+DXnHNNAH/kvf8z59zzOud9GpLNFm/33n+3c5ydSDZiXAvgbgCPdvuenXOrAHwBwPVIPue7APye9/5ox34IK57+5/wM/6fOYeY7yQ4vAXAPgHcBeAuS7KHbkfyCWVjxhH4TgD9Csrf5nQB+AOAvO+/7i977t3bOlWbHWvEW3tRZUwpJyuJHA+s89z2PgHyG3V63WLgsnjTOua1IPswHVgy/HsDvIElLO4xk508DwG4AzwXwUgBnKz68BUme7HMBXAfg14xzvQbA+wC8AclOplch2Yz/egBH0PkV0BHtZgDfAPABAKsB/CGAv3XOre0c7ktIbv41AP4YyY6nlef6oXPutWQpaSQ37nYkwikD+F9s3efwS53/jnbW+q9IvrR+G8ALAexCIs5zj3c9krziXwfwCSSJDDcBeHqyXPeCzuu6OdYLO8d6KYDbOhs+zof1GV5SXOpP3K865xpIksW/AWDl30ef9d6PA4Bzbj2SfbajnQ3zy865jyMR9icBOACf8N5Pdl7/ISRP6xC3APgz7/29nX8/bqzvdQC+6b3/Zuff/+Ccuw/Ay51zdyD5eX9TJ23un5xzX1s52Xv/LHZg7/1pAH979t/OuT8BcIexlvPxmwA+5r2f6BzvnQD2OefeuOI1f+y9rwD4tnNuGcCXvfenOq//ZyRi+l6Xx3q/934ZwF7n3GcA/CcAVtWQ832GlxSXunD/o+EIWplGtx1ADsDxFXmw6RWv2XTO6w8b59wK4GCX69sO4DXOuVeuGMshEdgmAHOdm3flebd2c2DnXBHAxwHcDGBVZ3jIOZe5wJ+Om/Dj7/swkvtn/YqxlY2Ly4F/n00P7OZY517vZ55nfef7DC8pLnXhWqzceTKJpIDbGuJFPY4fF8w247iTAK7o4pxnX/sF7/1bzn2hc247gFXOuYEV4t0WOAbjDwBcDeB67/0J59xzkPypcLaovZU2GDrHFBJxnGUbkp+lJ5H8Ld8L3RxrK4D9K+xT5znm+T7DS4rLWbg/wnt/3Dn3bQAf7aSoLSHJT93SqSbhAfy+c+7rSG54K3Xt0wA+5py7E8D9SERc994fRnJj7lrx2i8CuNc598tIfgbmkFS3eNx7f7jzs/n9ndjlLwB4JYC/6/JtDSF5ys0751YDeO859gcB/EbHafdsJH+3396xTSNx7uwCcKAz9mUAt3ZeP43kz46/6cSxu1zSj+jmWO/pOPl2Angjkj8rKF18hpcUl4VzqkveACAP4GEAcwD+D4CNHdunAPw9gIeQiPH/soN47/83gD9B4lg6A+CrSBxPQFLS5d3OuXnn3B92/mb+VSQe1mkkT4134N8+l9cicfjMIhHe51eeyzk37pz7TbKUTyDx2M4g8Ujffo79PUi+VOYAvL+z3rPvodR5D3d11vo8JEXhvoDE4/wEkhI3b2PX4Tx0c6zvIfEPfAeJV/nbXRzX+gwvKbRXWYgI0RNXiAiRcIWIEAlXiAiRcIWIEAlXiAiRcIWIEAlXiAiRcIWIEAlXiAj5/5xwzYdN9vFeAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f91bb153390>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "image_id = 108\n",
    "target_class = 1 # Integer in range 0-9\n",
    "pixels = 3\n",
    "model = lenet\n",
    "\n",
    "print('Attacking with target', class_names[target_class])\n",
    "_ = attack(image_id, model, target_class, pixel_count=pixels, verbose=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Collect Results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Armed with all the necessary tools to conduct a one pixel attack, the final step is to collect relevant statistics on the targeted and untargeted attack. The relevant data points are what percentage of images were we able to successfully attack for a given model, and how the number of pixels affect this percentage.\n",
    "\n",
    "We will loop through every combination of all models, perturbations of 1,3,5 pixels, images, and target classes (for the targeted attack). This will take a lot of computational resources and time, so [skip to the statistics section](#Attack-Statistics) if that's not your idea of fun."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def attack_all(models, samples=500, pixels=(1,3,5), targeted=False, \n",
    "               maxiter=75, popsize=400, verbose=False):\n",
    "    results = []\n",
    "    for model in models:\n",
    "        model_results = []\n",
    "        valid_imgs = correct_imgs[correct_imgs.name == model.name].img\n",
    "        img_samples = np.random.choice(valid_imgs, samples, replace=False)\n",
    "        \n",
    "        for pixel_count in pixels:\n",
    "            for i, img_id in enumerate(img_samples):\n",
    "                print('\\n', model.name, '- image', img_id, '-', i+1, '/', len(img_samples))\n",
    "                targets = [None] if not targeted else range(10)\n",
    "                \n",
    "                for target in targets:\n",
    "                    if targeted:\n",
    "                        print('Attacking with target', class_names[target])\n",
    "                        if target == y_test[img, 0]:\n",
    "                            continue\n",
    "                    result = attack(img_id, model, target, pixel_count, \n",
    "                                    maxiter=maxiter, popsize=popsize, \n",
    "                                    verbose=verbose)\n",
    "                    model_results.append(result)\n",
    "                    \n",
    "        results += model_results\n",
    "        helper.checkpoint(results, targeted)\n",
    "    return results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "untargeted = attack_all(models, samples=100, targeted=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "targeted = attack_all(models, samples=10, targeted=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Attack Statistics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Print the final results! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the results\n",
    "untargeted, targeted = helper.load_results()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "columns = ['model', 'pixels', 'image', 'true', 'predicted', 'success', 'cdiff', 'prior_probs', 'predicted_probs', 'perturbation']\n",
    "untargeted_results = pd.DataFrame(untargeted, columns=columns)\n",
    "targeted_results = pd.DataFrame(targeted, columns=columns)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Untargeted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style>\n",
       "    .dataframe thead tr:only-child th {\n",
       "        text-align: right;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>model</th>\n",
       "      <th>accuracy</th>\n",
       "      <th>pixels</th>\n",
       "      <th>attack_success_rate</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>lenet</td>\n",
       "      <td>0.7488</td>\n",
       "      <td>1</td>\n",
       "      <td>0.63</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>lenet</td>\n",
       "      <td>0.7488</td>\n",
       "      <td>3</td>\n",
       "      <td>0.92</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>lenet</td>\n",
       "      <td>0.7488</td>\n",
       "      <td>5</td>\n",
       "      <td>0.93</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>pure_cnn</td>\n",
       "      <td>0.8877</td>\n",
       "      <td>1</td>\n",
       "      <td>0.13</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>pure_cnn</td>\n",
       "      <td>0.8877</td>\n",
       "      <td>3</td>\n",
       "      <td>0.58</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>pure_cnn</td>\n",
       "      <td>0.8877</td>\n",
       "      <td>5</td>\n",
       "      <td>0.63</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>net_in_net</td>\n",
       "      <td>0.9074</td>\n",
       "      <td>1</td>\n",
       "      <td>0.34</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>net_in_net</td>\n",
       "      <td>0.9074</td>\n",
       "      <td>3</td>\n",
       "      <td>0.73</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>net_in_net</td>\n",
       "      <td>0.9074</td>\n",
       "      <td>5</td>\n",
       "      <td>0.73</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>resnet</td>\n",
       "      <td>0.9231</td>\n",
       "      <td>1</td>\n",
       "      <td>0.34</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>resnet</td>\n",
       "      <td>0.9231</td>\n",
       "      <td>3</td>\n",
       "      <td>0.79</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>resnet</td>\n",
       "      <td>0.9231</td>\n",
       "      <td>5</td>\n",
       "      <td>0.79</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>densenet</td>\n",
       "      <td>0.9467</td>\n",
       "      <td>1</td>\n",
       "      <td>0.31</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>densenet</td>\n",
       "      <td>0.9467</td>\n",
       "      <td>3</td>\n",
       "      <td>0.71</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>densenet</td>\n",
       "      <td>0.9467</td>\n",
       "      <td>5</td>\n",
       "      <td>0.69</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>wide_resnet</td>\n",
       "      <td>0.9534</td>\n",
       "      <td>1</td>\n",
       "      <td>0.19</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>wide_resnet</td>\n",
       "      <td>0.9534</td>\n",
       "      <td>3</td>\n",
       "      <td>0.58</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>wide_resnet</td>\n",
       "      <td>0.9534</td>\n",
       "      <td>5</td>\n",
       "      <td>0.65</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>capsnet</td>\n",
       "      <td>0.7982</td>\n",
       "      <td>1</td>\n",
       "      <td>0.19</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>capsnet</td>\n",
       "      <td>0.7982</td>\n",
       "      <td>3</td>\n",
       "      <td>0.39</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>capsnet</td>\n",
       "      <td>0.7982</td>\n",
       "      <td>5</td>\n",
       "      <td>0.36</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          model  accuracy  pixels  attack_success_rate\n",
       "0     lenet    0.7488       1                 0.63\n",
       "1     lenet    0.7488       3                 0.92\n",
       "2     lenet    0.7488       5                 0.93\n",
       "3      pure_cnn    0.8877       1                 0.13\n",
       "4      pure_cnn    0.8877       3                 0.58\n",
       "5      pure_cnn    0.8877       5                 0.63\n",
       "6    net_in_net    0.9074       1                 0.34\n",
       "7    net_in_net    0.9074       3                 0.73\n",
       "8    net_in_net    0.9074       5                 0.73\n",
       "9        resnet    0.9231       1                 0.34\n",
       "10       resnet    0.9231       3                 0.79\n",
       "11       resnet    0.9231       5                 0.79\n",
       "12     densenet    0.9467       1                 0.31\n",
       "13     densenet    0.9467       3                 0.71\n",
       "14     densenet    0.9467       5                 0.69\n",
       "15  wide_resnet    0.9534       1                 0.19\n",
       "16  wide_resnet    0.9534       3                 0.58\n",
       "17  wide_resnet    0.9534       5                 0.65\n",
       "18      capsnet    0.7982       1                 0.19\n",
       "19      capsnet    0.7982       3                 0.39\n",
       "20      capsnet    0.7982       5                 0.36"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "helper.attack_stats(untargeted_results, models, network_stats)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Targeted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style>\n",
       "    .dataframe thead tr:only-child th {\n",
       "        text-align: right;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>model</th>\n",
       "      <th>accuracy</th>\n",
       "      <th>pixels</th>\n",
       "      <th>attack_success_rate</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>lenet</td>\n",
       "      <td>0.7488</td>\n",
       "      <td>1</td>\n",
       "      <td>0.344444</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>lenet</td>\n",
       "      <td>0.7488</td>\n",
       "      <td>3</td>\n",
       "      <td>0.644444</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>lenet</td>\n",
       "      <td>0.7488</td>\n",
       "      <td>5</td>\n",
       "      <td>0.644444</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>pure_cnn</td>\n",
       "      <td>0.8877</td>\n",
       "      <td>1</td>\n",
       "      <td>0.066667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>pure_cnn</td>\n",
       "      <td>0.8877</td>\n",
       "      <td>3</td>\n",
       "      <td>0.133333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>pure_cnn</td>\n",
       "      <td>0.8877</td>\n",
       "      <td>5</td>\n",
       "      <td>0.188889</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>net_in_net</td>\n",
       "      <td>0.9074</td>\n",
       "      <td>1</td>\n",
       "      <td>0.100000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>net_in_net</td>\n",
       "      <td>0.9074</td>\n",
       "      <td>3</td>\n",
       "      <td>0.244444</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>net_in_net</td>\n",
       "      <td>0.9074</td>\n",
       "      <td>5</td>\n",
       "      <td>0.311111</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>resnet</td>\n",
       "      <td>0.9231</td>\n",
       "      <td>1</td>\n",
       "      <td>0.144444</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>resnet</td>\n",
       "      <td>0.9231</td>\n",
       "      <td>3</td>\n",
       "      <td>0.211111</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>resnet</td>\n",
       "      <td>0.9231</td>\n",
       "      <td>5</td>\n",
       "      <td>0.222222</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>densenet</td>\n",
       "      <td>0.9467</td>\n",
       "      <td>1</td>\n",
       "      <td>0.044444</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>densenet</td>\n",
       "      <td>0.9467</td>\n",
       "      <td>3</td>\n",
       "      <td>0.233333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>densenet</td>\n",
       "      <td>0.9467</td>\n",
       "      <td>5</td>\n",
       "      <td>0.288889</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>wide_resnet</td>\n",
       "      <td>0.9534</td>\n",
       "      <td>1</td>\n",
       "      <td>0.011111</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>wide_resnet</td>\n",
       "      <td>0.9534</td>\n",
       "      <td>3</td>\n",
       "      <td>0.188889</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>wide_resnet</td>\n",
       "      <td>0.9534</td>\n",
       "      <td>5</td>\n",
       "      <td>0.222222</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>capsnet</td>\n",
       "      <td>0.7982</td>\n",
       "      <td>1</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>capsnet</td>\n",
       "      <td>0.7982</td>\n",
       "      <td>3</td>\n",
       "      <td>0.044444</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>capsnet</td>\n",
       "      <td>0.7982</td>\n",
       "      <td>5</td>\n",
       "      <td>0.044444</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          model  accuracy  pixels  attack_success_rate\n",
       "0     lenet    0.7488       1             0.344444\n",
       "1     lenet    0.7488       3             0.644444\n",
       "2     lenet    0.7488       5             0.644444\n",
       "3      pure_cnn    0.8877       1             0.066667\n",
       "4      pure_cnn    0.8877       3             0.133333\n",
       "5      pure_cnn    0.8877       5             0.188889\n",
       "6    net_in_net    0.9074       1             0.100000\n",
       "7    net_in_net    0.9074       3             0.244444\n",
       "8    net_in_net    0.9074       5             0.311111\n",
       "9        resnet    0.9231       1             0.144444\n",
       "10       resnet    0.9231       3             0.211111\n",
       "11       resnet    0.9231       5             0.222222\n",
       "12     densenet    0.9467       1             0.044444\n",
       "13     densenet    0.9467       3             0.233333\n",
       "14     densenet    0.9467       5             0.288889\n",
       "15  wide_resnet    0.9534       1             0.011111\n",
       "16  wide_resnet    0.9534       3             0.188889\n",
       "17  wide_resnet    0.9534       5             0.222222\n",
       "18      capsnet    0.7982       1             0.000000\n",
       "19      capsnet    0.7982       3             0.044444\n",
       "20      capsnet    0.7982       5             0.044444"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "helper.attack_stats(targeted_results, models, network_stats)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Show some successful attacks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot 9 random successful attack images"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Untargeted Attack\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f91b1546b38>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print('Untargeted Attack')\n",
    "helper.visualize_attack(untargeted_results, class_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Targeted Attack\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f91b9546780>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print('Targeted Attack')\n",
    "helper.visualize_attack(targeted_results, class_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It appears that the accuracy of a model is not strongly correlated with the chance of performing a successful attack on an image. Perhaps surprisingly, the purely convolutional model is the most resistant CNN to these types of attacks. In addition, the capsule network CapsNet has the lowest attack success rate out of all the models, although it is still vulnerable to attack.\n",
    "\n",
    "[Part 2](1_one-pixel-attack-cifar10.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Credits\n",
    " -  This implemenation is based off of the original paper describing the one pixel attack: https://arxiv.org/abs/1710.08864\n",
    " - Base code for iPython notebook: https://github.com/09rohanchopra/cifar10\n",
    " - Keras Cifar10 models: https://github.com/BIGBALLON/cifar-10-cnn\n",
    " - Scipy's differential evolution implementation: https://docs.scipy.org/doc/scipy-0.17.0/reference/generated/scipy.optimize.differential_evolution.html\n",
    " - State of the art: https://github.com/RedditSota/state-of-the-art-result-for-machine-learning-problems\n",
    " - CapsNet Keras: https://github.com/XifengGuo/CapsNet-Keras\n",
    " - CapsNet with Cifar: https://github.com/theblackcat102/dynamic-routing-capsule-cifar"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
